class lhp_set_config_websocket_set_data{
    static lhp_deepcopy2(a,path,__b){
        if (typeof __b !== 'object' || __b === null ||path=='') {  
          //   console.log("???")
            return ;  
        }  
        __b=JSON.parse(JSON.stringify(__b));
        let path_lst=path.split(".");
        for(let i=0;i<path_lst.length-1;i++){a=a[path_lst[i]]}
        let stack=[]
        stack.push([[],__b])
       //  console.log("stack:",stack)
        while( stack.length){
            let new_stack=[]
            for (let i =0;i<stack.length;i++){
                let item=stack[i]
                let key=item[0],value=item[1]
                let temp_val=a
                let temp_b=__b
                if (key.length==0){
                    let kkpath=path_lst[path_lst.length-1];
                    if (kkpath in temp_val){
                        //为对象 则加入深度遍历队列 等待下一轮遍历
                        if(typeof temp_b === 'object'&&temp_b!=null&& temp_val[kkpath]!=null){for (
                         let k in temp_b){new_stack.push([ [...key, k],temp_b[k]])}}
                        //不为对象  则直接覆盖
                        else{
                      //   console.log('不拥有直接覆盖1',key,temp_b)
                            temp_val[kkpath]=temp_b}
                    }
                    //不拥有 则直接覆盖
                    else{
                      //   console.log('不拥有直接覆盖2',key,temp_b)
                        //如果是数组 则直接插入
                        if (Array.isArray(temp_val)){
                            temp_val.push(temp_b)
                        }else{
                        //不是数组 就按照对象设置属性
                            temp_val[kkpath]=temp_b
                        }
                        
                    }
                break}
                temp_val=temp_val[path_lst[path_lst.length-1]]
                for(let j =0;j<key.length;j++){temp_b=temp_b[key[j]]}
                for(let j =0;j<key.length-1;j++){temp_val=temp_val[key[j]]}
                
                //如果a 拥有b这个属性 判断是否为对象，从而进行深度遍历
                if (key[key.length-1] in temp_val){
                   //  console.log("如果a拥有b这个属性",key[key.length-1])
                    //为对象 则加入深度遍历队列 等待下一轮遍历
                    if(typeof temp_b === 'object' &&temp_b !=null && temp_val[key[key.length-1]]!=null){
                      
                      // console.log("????")
                      for (let k in temp_b){
                        new_stack.push([ [...key, k],temp_b[k]])}}
                    //不为对象  则直接覆盖
                    else{
                   //  console.log('不拥有直接覆盖3',key,temp_b)
                        temp_val[key[key.length-1]]=temp_b}
                }
                //不拥有 则直接覆盖
                else{
                   //  console.log('不拥有直接覆盖4',key,temp_b)
                    //如果是数组 则直接插入
                    if (Array.isArray(temp_val)){
                        temp_val.push(temp_b)
                    }else{
                    //不是数组 就按照对象设置属性
                        temp_val[key[key.length-1]]=temp_b
                    }
                    
                }
                
            }
            stack=new_stack
        }
    
    }
    static postput(obj={}){
        // console.log('数据对象更新:',obj)
        try{
  
            this.lhp_deepcopy2(obj.data,obj.path,obj.copy_data);
            return {"type":'ok'}
        }
        catch(err){
            return {"type":'error',"message":"lhp_set_config_websocket_set_data postput异常"+err}
        }
    }
    static delete(obj={}){
        try{
            let change_obj=obj.data;
            if (obj.path.indexOf(".") !== -1){
                let path_lst=obj.path.split(".");
                if (path_lst.length<=1){return {"type":'error',"message":"delete异常 数量小于等于1"}}
                for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
                if(typeof change_obj =="object") {  
                    if (Array.isArray(change_obj)){
                        change_obj.splice(path_lst[path_lst.length-1],1);
  
                    }else{
                        delete change_obj[path_lst[path_lst.length-1]]
                    }
            }}else{return {"type":'error',"message":"delete异常 数量小于2"}}
            return {"type":'ok'}
  
        }catch(err){return {"type":'error',"message":"lhp_set_config_websocket_set_data delete异常"+err}}
    }
    static clear(obj={}){
        try{
            let md5_val=null;
            let res={"type":'ok'}
            let change_obj=obj.data;
            let last_key=null;
            if (obj.path.indexOf(".") !== -1){
                let path_lst=obj.path.split(".");
                for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
                last_key=path_lst[path_lst.length-1];
            }else{
                last_key=obj.path;
            
            }
            let temp_val=change_obj[last_key]
            if (typeof temp_val=='object') {  
                // 注意：这里会匹配到null，因为null也是object类型  
                // 需要额外检查是否为null  
                if (temp_val === null) {  
                    change_obj[last_key] = null; // 或者你可以将null也设置为{}  
                } else if (Array.isArray(temp_val)) {  
                    change_obj[last_key] = [];  
                    md5_val=[];
                } else {  
                    change_obj[last_key] = {};  
                    md5_val={};
                }  
            }else if (typeof temp_val=='string'){
            change_obj[last_key] = '';  
            md5_val='';
            }else if (typeof temp_val=='number'){
            change_obj[last_key] = 0;  
            md5_val=0;
            }else if (typeof temp_val=='boolean'){ 
            change_obj[last_key] = false;  
            md5_val=false;}
        // console.log("clear params obj",obj)
        // console.log("change_obj[last_key]",change_obj[last_key])
        // console.log("md5_val",md5_val)
        if(obj.md5_flag==true){res.md5=md5(JSON.stringify(md5_val))}
        return obj
  
        }catch(err){
            return {"type":'error',"message":"lhp_set_config_websocket_set_data clear异常"+err}
        }
    }
    
  static insert(obj={}){
    console.log("config insert1 obj",3,obj);
    try{
        // let path=obj.path;//要插入的路径
        let path_lst=obj.path.split(".");
        let before_idx=obj.before_idx;//要插入到第几个元素之前
        let change_obj=obj.data;//要插入的数据
        if (path_lst.length<=1){return {"type":'error',"message":"delete异常 数量小于等于1"}}
        for (let i=0;i<path_lst.length;i++){change_obj=change_obj[path_lst[i]]}
        if (before_idx===null || (before_idx===undefined)){
            console.log("config insert2",2,'追加数据');
            change_obj.push(obj.copy_data);
        }else{
            console.log("config insert2",2,'-1插入数据前',JSON.parse(JSON.stringify(change_obj)));
            change_obj.splice(before_idx,0,obj.copy_data); 
            console.log("config insert2",2,'-2插入数据后',JSON.parse(JSON.stringify(change_obj)));
        }
        console.log("config insert3 insert后的数据",3,JSON.parse(JSON.stringify(obj.data)));
        return {"type":'ok'}

    }catch (err){
        let error_message= {"type":'error',"message":"lhp_set_config_websocket_set_data insert异常"}
        console.log(error_message,'\n',err);
        return error_message}
  }
  static set(obj){
    //obj.base_data 是原数据
if (obj.type=="change_data"){
    if(obj.data_type=="postput"){
            let res=lhp_set_config_websocket_set_data.postput({
                data:obj.base_data,
                path:obj.path,
                copy_data:obj.data
            })
            if(res.type=="error"){
                console.log(res.message);
                return
            }
    }
    else if(obj.data_type=="delete"){
        let res=null;
        if (typeof obj.path==='string'){
            res=this.delete({
            data:obj.base_data,
            path:obj.path,
            })
            if(res.type=="error"){
                console.log(res.message);
                return
            }
        }
        else if( Array.isArray(obj.path)){
            for (let zzzz=0;zzzz<obj.path.length;zzzz++){
                res=this.delete({
                data:obj.base_data,
                path:obj.path[zzzz],
                })
                if(res.type=="error"){
                    console.log(res.message);
                    return
                }

            }
        }
    }
    else if (obj.data_type=="clear"){
    
    let res=lhp_set_config_websocket_set_data.clear({
        md5_flag:true,
        data:obj.base_data,
        path:obj.path,
    })
if(res.type=="error"){
    console.log(res.message);
    return
}
    }
    else if(obj.data_type=='set_list'){
        if(!(obj.delete===undefined)){
        for (let idx_=0;idx_<obj.delete.length;idx_++){
            if (typeof obj.delete[idx_].path==='string'){
                res=lhp_set_config_websocket_set_data.delete({
                data:obj.base_data,
                path:obj.delete[idx_].path,
                })
            }else if( Array.isArray(obj.delete[idx_].path)){
                for (let zzzz=0;zzzz<obj.delete[idx_].path.length;zzzz++){
                    res=lhp_set_config_websocket_set_data.delete({
                    data:obj.base_data,
                    path:obj.delete[idx_].path[zzzz],
                    })

                }
            }
        }
        }
        if(!(obj.clear===undefined)){
            for (let idx_=0;idx_<obj.clear.length;idx_++){
                let res=lhp_set_config_websocket_set_data.clear({
                    md5_flag:true,
                    data:obj.base_data,
                    path:obj.clear[idx_].path,
                })
            }
        }
        if(!(obj.postput===undefined)){

            for (let idx_=0;idx_<obj.postput.length;idx_++){
                let res=lhp_set_config_websocket_set_data.postput({
                    md5_flag:true,
                    data:obj.base_data,
                    path:obj.postput[idx_].path,
                    copy_data:obj.postput[idx_].data
                })
            }
        }
        if(!(obj.insert===undefined)){

            for (let idx_=0;idx_<obj.insert.length;idx_++){
                let res=lhp_set_config_websocket_set_data.insert({
                    md5_flag:true,
                    data:obj.base_data,
                    path:obj.insert[idx_].path,
                    copy_data:obj.insert[idx_].data,
                    before_idx:obj.insert[idx_].before_idx
                }) 
            }
        }
}

}
  }
}